package cn.net.csit.platform_cloud.api.server;

import cn.net.csit.platform_cloud.basicmodel.service.IBasicObjectDictionaryService;
import cn.net.csit.platform_cloud.basicmodel.service.IBasicPropertyDictionaryService;
import cn.net.csit.platform_cloud.utils.BaseResult;
import cn.net.csit.platform_cloud.utils.ResultUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * @ClassName:
 * @Author:yanwenjuan
 * @Date:2019/4/1714:19
 * @Description:
 */
@RequestMapping(value = "/mesPlanServerApiImpl")
@RestController
public class MesPlanServerApiImpl {
    @Autowired
    IBasicObjectDictionaryService iBasicObjectDictionaryService;
    @Autowired
    IBasicPropertyDictionaryService basicPropertyDictionaryService;

    @GetMapping("/getPlanPropTemplete")
    public BaseResult getPlanPropTemplete(@RequestParam Map<String, String> map) {
       // map.put("organ_type","plan");
        //1.定义返回结果对象集合
        List<Map<String,Object>> listResult=new ArrayList<>();
        //2.根据参数获取数据
        List<Map<String,String>> listMap=iBasicObjectDictionaryService.getObjPropByOrganType(map);
        if(null!=listMap&&listMap.size()>0){
           //3.遍历数据，按照对象uuid，进行分组
           for(Map<String,String> mmap:listMap){//从数据库查到的集合
               //判断集合listResult是否为空,
               if(listResult.size()==0){
                   // 如果为空，新建一个Map<String,Object>将mmap数据放入listResult中
                   Map<String,Object> mapres=new HashMap<>();
                   mapres.put("objId",mmap.get("uuid"));
                   mapres.put("objCode",mmap.get("obj_code"));
                   mapres.put("objName",mmap.get("obj_name"));
                   //定义返回对象属性集合
                   List<Map<String,Object>> listpropResult=new ArrayList<>();
                   Map<String,Object> dp=new HashMap<>();
                   dp.put("prop_uuid",mmap.get("prop_uuid"));
                   dp.put("prop_code",mmap.get("prop_code"));
                   dp.put("prop_name",mmap.get("prop_name"));
                   dp.put("prop_type",mmap.get("prop_type"));
                   listpropResult.add(dp);
                   //判断是否为默认属性defaultAttr，扩展属性specialAttr
                   //如果是则放入defaultAttr，否则specialAttr
                   if(null!=mmap.get("prop_is_multiterm")&&mmap.get("prop_is_multiterm").equals("1")){
                       mapres.put("defaultAttr",listpropResult);
                   }else{
                       mapres.put("specialAttr",listpropResult);
                   }
                   listResult.add(mapres);
               }else{
                   //否则，遍历对象集合listResult
                   boolean flagObj=false;//false:没有对象
                   for(int i=0;i<listResult.size();i++){
                       if(flagObj==true){
                            break;
                       }
                        //判断mmap的对象是否在集合listResult中
                       if(listResult.get(i).get("objId").equals(mmap.get("uuid"))){
                           flagObj=true;
                           Map<String,Object> df=new HashMap<>();
                           df.put("prop_uuid",mmap.get("prop_uuid"));
                           df.put("prop_code",mmap.get("prop_code"));
                           df.put("prop_name",mmap.get("prop_name"));
                           df.put("prop_type",mmap.get("prop_type"));
                           //判断是否为默认属性defaultAttr，扩展属性specialAttr
                           //如果是则放入defaultAttr，否则specialAttr
                           if(null!=mmap.get("prop_is_multiterm")&&mmap.get("prop_is_multiterm").equals("1")){
                               // 如果在对象集合里，判断属性集合是否为空，
                               List<Map<String,Object>> listMapAttr= (List<Map<String, Object>>) listResult.get(i).get("defaultAttr");
                               if(null!=listMapAttr&&listMapAttr.size()>0){
                                   // 如果不空，获取原来的属性集合，追加进去
                                   listMapAttr.add(df);
                                   listResult.get(i).put("defaultAttr",listMapAttr);
                                   break;
                               }else{
                                   // 如果为空，新建属性集合，追加进去
                                   listMapAttr=new ArrayList<>();
                                   listMapAttr.add(df);
                                   listResult.get(i).put("defaultAttr",listMapAttr);
                                   break;
                               }
                           }else{
                               // 如果在对象集合里，判断属性集合是否为空，
                               List<Map<String,Object>> listMapAttr= (List<Map<String, Object>>) listResult.get(i).get("specialAttr");
                               if(null!=listMapAttr&&listMapAttr.size()>0){
                                   // 如果不空，获取原来的属性集合，追加进去
                                   listMapAttr.add(df);
                                   listResult.get(i).put("specialAttr",listMapAttr);
                                   break;
                               }else{
                                   // 如果为空，新建属性集合，追加进去
                                   listMapAttr=new ArrayList<>();
                                   listMapAttr.add(df);
                                   listResult.get(i).put("specialAttr",listMapAttr);
                                   break;
                               }
                           }



                       }else{
                           // 如果不在对象集合里
                            continue;
                       }

                   }

                    // 如果不在对象集合里
                    if(flagObj==false){
                        //新建对象，新建属性集合
                        // 如果为空，新建一个Map<String,Object>将mmap数据放入listResult中
                        Map<String,Object> mapres=new HashMap<>();
                        mapres.put("objId",mmap.get("uuid"));
                        mapres.put("objCode",mmap.get("obj_code"));
                        mapres.put("objName",mmap.get("obj_name"));
                        //定义返回对象属性集合
                        List<Map<String,Object>> listpropResult=new ArrayList<>();
                        Map<String,Object> dp=new HashMap<>();
                        dp.put("prop_uuid",mmap.get("prop_uuid"));
                        dp.put("prop_code",mmap.get("prop_code"));
                        dp.put("prop_name",mmap.get("prop_name"));
                        dp.put("prop_type",mmap.get("prop_type"));
                        listpropResult.add(dp);
                        //判断是否为默认属性defaultAttr，扩展属性specialAttr
                        //如果是则放入defaultAttr，否则specialAttr
                        if(null!=mmap.get("prop_is_multiterm")&&mmap.get("prop_is_multiterm").equals("1")){
                            mapres.put("defaultAttr",listpropResult);
                        }else{
                            mapres.put("specialAttr",listpropResult);
                        }
                        listResult.add(mapres);
                    }
               }

           }
       }
        return ResultUtil.success(listResult);
    }



    //根据属性编码查询属性名称接口4
    @GetMapping("/getPropNameByPropCode")
    public BaseResult getPropNameByPropCode(@RequestParam Map<String, Object> map){
        Map<String, String> result=basicPropertyDictionaryService.getPropNameByPropCode(map);
        return ResultUtil.success(result);
    }
}
